home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1995 June / MacFormat 25.iso / Shareware City / Developers / OutOfPhase1.1 Source / OutOfPhase Folder / Main.c < prev    next >
C/C++ Source or Header  |  1995-01-05  |  22KB  |  814 lines
  1. /* Main.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #define Including_Main_c
  26.  
  27. #include "MiscInfo.h"
  28. #include "Audit.h"
  29. #include "Debug.h"
  30. #include "Definitions.h"
  31.  
  32. #include "Main.h"
  33. #include "Screen.h"
  34. #include "Alert.h"
  35. #include "Scroll.h"
  36. #include "GrowIcon.h"
  37. #include "StartupOpen.h"
  38. #include "DataMunging.h"
  39. #include "Memory.h"
  40. #include "MainWindowStuff.h"
  41. #include "WindowDispatcher.h"
  42. #include "AboutBox.h"
  43. #include "EditImages.h"
  44. #include "NoteImages.h"
  45. #include "NoteButtonImages.h"
  46. #include "LittleButtonImages.h"
  47. #include "Factoring.h"
  48. #include "Files.h"
  49. #include "GlobalWindowMenuList.h"
  50. #include "PlayAIFFFile.h"
  51.  
  52.  
  53. #define STARTUPDELAY (3)
  54.  
  55.  
  56. char*                            GlobalSearchString;
  57. char*                            GlobalReplaceString;
  58.  
  59. MenuType*                    mmAppleMenu;
  60. MenuType*                    mmFileMenu;
  61. MenuType*                    mmEditMenu;
  62. MenuType*                    mmSearchMenu;
  63. MenuType*                    mmObjectsMenu;
  64. MenuType*                    mmFunctionMenu;
  65. MenuType*                    mmSampleMenu;
  66. MenuType*                    mmWindowMenu;
  67.  
  68. MenuItemType*            mAboutThisProgram;
  69. MenuItemType*            mNewFile;
  70. MenuItemType*            mOpenFile;
  71. MenuItemType*            mCloseFile;
  72. MenuItemType*            mSaveFile;
  73. MenuItemType*            mSaveAs;
  74. MenuItemType*            mSetTabSize;
  75. MenuItemType*            mPlay;
  76. MenuItemType*            mPlayThisTrackFromHere;
  77. MenuItemType*            mPlayAllTracksFromHere;
  78. MenuItemType*            mPlayAIFFFile;
  79. MenuItemType*            mQuit;
  80.  
  81. MenuItemType*            mUndo;
  82. MenuItemType*            mCut;
  83. MenuItemType*            mCopy;
  84. MenuItemType*            mPaste;
  85. MenuItemType*            mClear;
  86. MenuItemType*            mSelectAll;
  87. MenuItemType*            mShiftLeft;
  88. MenuItemType*            mShiftRight;
  89. MenuItemType*            mBalanceParens;
  90. MenuItemType*            mEnterSelection;
  91. MenuItemType*            mFind;
  92. MenuItemType*            mFindAgain;
  93. MenuItemType*            mReplace;
  94. MenuItemType*            mReplaceAndFindAgain;
  95. MenuItemType*            mShowSelection;
  96.  
  97. MenuItemType*            mNewSample;
  98. MenuItemType*            mNewFunction;
  99. MenuItemType*            mNewAlgoSample;
  100. MenuItemType*            mNewWaveTable;
  101. MenuItemType*            mNewAlgoWaveTable;
  102. MenuItemType*            mNewTrack;
  103. MenuItemType*            mNewInstrument;
  104. MenuItemType*            mBuildFunction;
  105. MenuItemType*            mUnbuildFunction;
  106. MenuItemType*            mUnbuildAllFunctions;
  107. MenuItemType*            mBuildEntireProject;
  108. MenuItemType*            mDisassembleFunction;
  109. MenuItemType*            mOpenObject;
  110. MenuItemType*            mEditTrackAttributes;
  111. MenuItemType*            mDeleteObject;
  112. MenuItemType*            mCalculator;
  113. MenuItemType*            mEvaluateCalc;
  114. MenuItemType*            mAlgoSampToSample;
  115. MenuItemType*            mSampleEditLoop1;
  116. MenuItemType*            mSampleEditLoop2;
  117. MenuItemType*            mSampleEditLoop3;
  118. MenuItemType*            mImportWAVFormat;
  119. MenuItemType*            mImportAIFFFormat;
  120. MenuItemType*            mImportRAWFormat;
  121. MenuItemType*            mExportWAVFormat;
  122. MenuItemType*            mExportAIFFFormat;
  123. MenuItemType*            mExportRAWFormat;
  124. MenuItemType*            mCopyObject;
  125. MenuItemType*            mPasteObject;
  126. MenuItemType*            mTransposeSelection;
  127. MenuItemType*            mGotoMeasureBar;
  128. MenuItemType*            mEditScoreEffects;
  129.  
  130.  
  131. static void                FileOpener(FileSpec* Where)
  132.     {
  133.         MyBoolean                    SendFileToOpenDoc;
  134.         MyBoolean                    SendFileToAIFFPlayer;
  135.         FileType*                    FileDesc;
  136.  
  137.         SendFileToOpenDoc = False;
  138.         SendFileToAIFFPlayer = False;
  139.         /* see what kind of a file it is */
  140.         if (!OpenFile(Where,&FileDesc,eReadOnly))
  141.             {
  142.                 AlertHalt("Unable to open the file.",NIL);
  143.             }
  144.          else
  145.             {
  146.                 char                            Buffer[12];
  147.  
  148.                 if ((0 == ReadFromFile(FileDesc,Buffer,12))
  149.                     && MemEqu(Buffer,"FORM",4)
  150.                     && (MemEqu(&(Buffer[8]),"AIFF",4) || MemEqu(&(Buffer[8]),"AIFC",4)))
  151.                     {
  152.                         SendFileToAIFFPlayer = True;
  153.                     }
  154.                  else
  155.                     {
  156.                         SendFileToOpenDoc = True;
  157.                     }
  158.                 CloseFile(FileDesc);
  159.             }
  160.         /* handle the file in the appropriate way */
  161.         if (SendFileToAIFFPlayer)
  162.             {
  163.                 PlayAIFFFileSpec(Where);
  164.                 DisposeFileSpec(Where);
  165.             }
  166.         else if (SendFileToOpenDoc)
  167.             {
  168.                 OpenDocument(Where);
  169.             }
  170.         else
  171.             {
  172.                 DisposeFileSpec(Where);
  173.             }
  174.     }
  175.  
  176.  
  177. int                                main(int argc, char* argv[])
  178.     {
  179.         MyBoolean                TryToOpenUntitledDocument;
  180.         MyBoolean                ContinueFlag;
  181. #if 0
  182.         double                    StartupTime;
  183.         MyBoolean                InitialAboutBoxStillVisible;
  184. #endif
  185.  
  186.         APRINT(("+main"));
  187.  
  188.         /* level 0 initialization */
  189.         if (!InitializeScreen())
  190.             {
  191.                 goto InitScreenFailurePoint;
  192.             }
  193.         SetErrorBeepEnable(False); /* it's a music program, so disable nasty noises */
  194.  
  195.         /* level 1 initialization */
  196.         if (!InitializeAlertSubsystem())
  197.             {
  198.                 goto InitAlertFailurePoint;
  199.             }
  200.         if (!InitializeGrowIcon())
  201.             {
  202.                 goto InitGrowIconFailurePoint;
  203.             }
  204.  
  205.         /* application initialization */
  206.         if (!InitializeFactoring())
  207.             {
  208.                 goto InitFactoringFailurePoint;
  209.             }
  210.         if (!InitializeEditImages())
  211.             {
  212.                 goto InitEditImagesFailurePoint;
  213.             }
  214.         if (!InitializeNoteImages())
  215.             {
  216.                 goto InitNoteImagesFailurePoint;
  217.             }
  218.         if (!InitializeNoteButtonImages())
  219.             {
  220.                 goto InitNoteButtonImagesFailurePoint;
  221.             }
  222.         if (!InitializeLittleButtonImages())
  223.             {
  224.                 goto InitializeLittleButtonImagesFailurePoint;
  225.             }
  226.         if (!InitializeWindowDispatcher())
  227.             {
  228.                 goto InitWindowDispatcherFailurePoint;
  229.             }
  230.         if (!InitializeDocuments())
  231.             {
  232.                 goto InitDocumentsFailurePoint;
  233.             }
  234.         GlobalSearchString = AllocPtrCanFail(0,"GlobalSearchString");
  235.         if (GlobalSearchString == NIL)
  236.             {
  237.                 goto AllocGlobalSearchStringFailurePoint;
  238.             }
  239.         GlobalReplaceString = AllocPtrCanFail(0,"GlobalReplaceString");
  240.         if (GlobalReplaceString == NIL)
  241.             {
  242.                 goto AllocGlobalReplaceStringFailurePoint;
  243.             }
  244.         if (!InitializeGlobalWindowMenuList())
  245.             {
  246.                 goto InitializeGlobalMenuWindowListFailurePoint;
  247.             }
  248.  
  249. #if 0
  250. #if !DEBUG
  251.         ShowAboutBox();
  252. #endif
  253.         InitialAboutBoxStillVisible = True;
  254.         StartupTime = ReadTimer();
  255. #endif
  256.  
  257.         mmAppleMenu = MakeAppleMenu();
  258.         if (mmAppleMenu == NIL)
  259.             {
  260.                 goto MakeAppleMenuFailurePoint;
  261.             }
  262.         mAboutThisProgram = MakeNewMenuItem(mmAppleMenu,"About Out Of Phase...",0);
  263.         if (mAboutThisProgram == NIL)
  264.             {
  265.                 goto MakeFileMenuFailurePoint;
  266.             }
  267.         ShowMenu(mmAppleMenu);
  268.  
  269.         mmFileMenu = MakeNewMenu("File");
  270.         if (mmFileMenu == NIL)
  271.             {
  272.                 goto MakeFileMenuFailurePoint;
  273.             }
  274.         mNewFile = MakeNewMenuItem(mmFileMenu,"New",'N');
  275.         if (mNewFile == NIL)
  276.             {
  277.                 goto MakeEditMenuFailurePoint;
  278.             }
  279.         mOpenFile = MakeNewMenuItem(mmFileMenu,"Open...",'O');
  280.         if (mOpenFile == NIL)
  281.             {
  282.                 goto MakeEditMenuFailurePoint;
  283.             }
  284.         mCloseFile = MakeNewMenuItem(mmFileMenu,"Close",'W');
  285.         if (mCloseFile == NIL)
  286.             {
  287.                 goto MakeEditMenuFailurePoint;
  288.             }
  289.         AppendSeparator(mmFileMenu);
  290.         mSaveFile = MakeNewMenuItem(mmFileMenu,"Save",'S');
  291.         if (mSaveFile == NIL)
  292.             {
  293.                 goto MakeEditMenuFailurePoint;
  294.             }
  295.         mSaveAs = MakeNewMenuItem(mmFileMenu,"Save As...",0);
  296.         if (mSaveAs == NIL)
  297.             {
  298.                 goto MakeEditMenuFailurePoint;
  299.             }
  300.         AppendSeparator(mmFileMenu);
  301.         mSetTabSize = MakeNewMenuItem(mmFileMenu,"Set Tab Size...",0);
  302.         if (mSetTabSize == NIL)
  303.             {
  304.                 goto MakeEditMenuFailurePoint;
  305.             }
  306.         AppendSeparator(mmFileMenu);
  307.         mPlay = MakeNewMenuItem(mmFileMenu,"Play...",'P');
  308.         if (mPlay == NIL)
  309.             {
  310.                 goto MakeEditMenuFailurePoint;
  311.             }
  312.         mPlayThisTrackFromHere = MakeNewMenuItem(mmFileMenu,"Play This Track",'T');
  313.         if (mPlayThisTrackFromHere == NIL)
  314.             {
  315.                 goto MakeEditMenuFailurePoint;
  316.             }
  317.         mPlayAllTracksFromHere = MakeNewMenuItem(mmFileMenu,"Play All Tracks",'Y');
  318.         if (mPlayAllTracksFromHere == NIL)
  319.             {
  320.                 goto MakeEditMenuFailurePoint;
  321.             }
  322.         AppendSeparator(mmFileMenu);
  323.         mPlayAIFFFile = MakeNewMenuItem(mmFileMenu,"Play AIFF File",0);
  324.         if (mPlayAIFFFile == NIL)
  325.             {
  326.                 goto MakeEditMenuFailurePoint;
  327.             }
  328.         AppendSeparator(mmFileMenu);
  329.         mQuit = MakeNewMenuItem(mmFileMenu,"Quit",'Q');
  330.         if (mQuit == NIL)
  331.             {
  332.                 goto MakeEditMenuFailurePoint;
  333.             }
  334.         ShowMenu(mmFileMenu);
  335.  
  336.         mmEditMenu = MakeNewMenu("Edit");
  337.         if (mmEditMenu == NIL)
  338.             {
  339.                 goto MakeEditMenuFailurePoint;
  340.             }
  341.         mUndo = MakeNewMenuItem(mmEditMenu,"Undo",'Z');
  342.         if (mUndo == NIL)
  343.             {
  344.                 goto MakeSearchMenuFailurePoint;
  345.             }
  346.         AppendSeparator(mmEditMenu);
  347.         mCut = MakeNewMenuItem(mmEditMenu,"Cut",'X');
  348.         if (mCut == NIL)
  349.             {
  350.                 goto MakeSearchMenuFailurePoint;
  351.             }
  352.         mCopy = MakeNewMenuItem(mmEditMenu,"Copy",'C');
  353.         if (mCopy == NIL)
  354.             {
  355.                 goto MakeSearchMenuFailurePoint;
  356.             }
  357.         mPaste = MakeNewMenuItem(mmEditMenu,"Paste",'V');
  358.         if (mPaste == NIL)
  359.             {
  360.                 goto MakeSearchMenuFailurePoint;
  361.             }
  362.         mClear = MakeNewMenuItem(mmEditMenu,"Clear",0);
  363.         if (mClear == NIL)
  364.             {
  365.                 goto MakeSearchMenuFailurePoint;
  366.             }
  367.         mSelectAll = MakeNewMenuItem(mmEditMenu,"Select All",'A');
  368.         if (mSelectAll == NIL)
  369.             {
  370.                 goto MakeSearchMenuFailurePoint;
  371.             }
  372.         AppendSeparator(mmEditMenu);
  373.         mShiftLeft = MakeNewMenuItem(mmEditMenu,"Shift Left",'L');
  374.         if (mShiftLeft == NIL)
  375.             {
  376.                 goto MakeSearchMenuFailurePoint;
  377.             }
  378.         mShiftRight = MakeNewMenuItem(mmEditMenu,"Shift Right",'R');
  379.         if (mShiftRight == NIL)
  380.             {
  381.                 goto MakeSearchMenuFailurePoint;
  382.             }
  383.         mBalanceParens = MakeNewMenuItem(mmEditMenu,"Balance",'B');
  384.         if (mBalanceParens == NIL)
  385.             {
  386.                 goto MakeSearchMenuFailurePoint;
  387.             }
  388.         AppendSeparator(mmEditMenu);
  389.         mTransposeSelection = MakeNewMenuItem(mmEditMenu,"Transpose Selection",0);
  390.         if (mTransposeSelection == NIL)
  391.             {
  392.                 goto MakeSearchMenuFailurePoint;
  393.             }
  394.         mGotoMeasureBar = MakeNewMenuItem(mmEditMenu,"Go To Measure...",0);
  395.         if (mGotoMeasureBar == NIL)
  396.             {
  397.                 goto MakeSearchMenuFailurePoint;
  398.             }
  399.         AppendSeparator(mmEditMenu);
  400.         mShowSelection = MakeNewMenuItem(mmEditMenu,"Show Selection",0);
  401.         if (mShowSelection == NIL)
  402.             {
  403.                 goto MakeSearchMenuFailurePoint;
  404.             }
  405.         ShowMenu(mmEditMenu);
  406.  
  407.         mmSearchMenu = MakeNewMenu("Search");
  408.         if (mmSearchMenu == NIL)
  409.             {
  410.                 goto MakeSearchMenuFailurePoint;
  411.             }
  412.         mEnterSelection = MakeNewMenuItem(mmSearchMenu,"Enter Selection",'E');
  413.         if (mEnterSelection == NIL)
  414.             {
  415.                 goto MakeObjectsMenuFailurePoint;
  416.             }
  417.         mFind = MakeNewMenuItem(mmSearchMenu,"Find...",'F');
  418.         if (mFind == NIL)
  419.             {
  420.                 goto MakeObjectsMenuFailurePoint;
  421.             }
  422.         mFindAgain = MakeNewMenuItem(mmSearchMenu,"Find Again",'G');
  423.         if (mFindAgain == NIL)
  424.             {
  425.                 goto MakeObjectsMenuFailurePoint;
  426.             }
  427.         mReplace = MakeNewMenuItem(mmSearchMenu,"Replace",'=');
  428.         if (mReplace == NIL)
  429.             {
  430.                 goto MakeObjectsMenuFailurePoint;
  431.             }
  432.         mReplaceAndFindAgain = MakeNewMenuItem(mmSearchMenu,"Replace and Find Again",'H');
  433.         if (mReplaceAndFindAgain == NIL)
  434.             {
  435.                 goto MakeObjectsMenuFailurePoint;
  436.             }
  437.         ShowMenu(mmSearchMenu);
  438.  
  439.         mmObjectsMenu = MakeNewMenu("Objects");
  440.         if (mmObjectsMenu == NIL)
  441.             {
  442.                 goto MakeObjectsMenuFailurePoint;
  443.             }
  444.         mDeleteObject = MakeNewMenuItem(mmObjectsMenu,"Delete",0);
  445.         if (mDeleteObject == NIL)
  446.             {
  447.                 goto MakeFunctionMenuFailurePoint;
  448.             }
  449.         AppendSeparator(mmObjectsMenu);
  450.         mOpenObject = MakeNewMenuItem(mmObjectsMenu,"Edit",0);
  451.         if (mOpenObject == NIL)
  452.             {
  453.                 goto MakeFunctionMenuFailurePoint;
  454.             }
  455.         mEditTrackAttributes = MakeNewMenuItem(mmObjectsMenu,"Edit Track Attributes",0);
  456.         if (mEditTrackAttributes == NIL)
  457.             {
  458.                 goto MakeFunctionMenuFailurePoint;
  459.             }
  460.         mEditScoreEffects = MakeNewMenuItem(mmObjectsMenu,"Edit Score Effects",0);
  461.         if (mEditScoreEffects == NIL)
  462.             {
  463.                 goto MakeFunctionMenuFailurePoint;
  464.             }
  465.         AppendSeparator(mmObjectsMenu);
  466.         mCopyObject = MakeNewMenuItem(mmObjectsMenu,"Copy Object",0);
  467.         if (mCopyObject == NIL)
  468.             {
  469.                 goto MakeFunctionMenuFailurePoint;
  470.             }
  471.         AppendSeparator(mmObjectsMenu);
  472.         mPasteObject = MakeNewMenuItem(mmObjectsMenu,"Paste Object",0);
  473.         if (mPasteObject == NIL)
  474.             {
  475.                 goto MakeFunctionMenuFailurePoint;
  476.             }
  477.         AppendSeparator(mmObjectsMenu);
  478.         mNewTrack = MakeNewMenuItem(mmObjectsMenu,"New Track",0);
  479.         if (mNewTrack == NIL)
  480.             {
  481.                 goto MakeFunctionMenuFailurePoint;
  482.             }
  483.         mNewInstrument = MakeNewMenuItem(mmObjectsMenu,"New Instrument",0);
  484.         if (mNewInstrument == NIL)
  485.             {
  486.                 goto MakeFunctionMenuFailurePoint;
  487.             }
  488.         mNewWaveTable = MakeNewMenuItem(mmObjectsMenu,"New Wave Table",0);
  489.         if (mNewWaveTable == NIL)
  490.             {
  491.                 goto MakeFunctionMenuFailurePoint;
  492.             }
  493.         mNewAlgoWaveTable = MakeNewMenuItem(mmObjectsMenu,"New Algorithmic Wave Table",0);
  494.         if (mNewAlgoWaveTable == NIL)
  495.             {
  496.                 goto MakeFunctionMenuFailurePoint;
  497.             }
  498.         mNewSample = MakeNewMenuItem(mmObjectsMenu,"New Sample",0);
  499.         if (mNewSample == NIL)
  500.             {
  501.                 goto MakeFunctionMenuFailurePoint;
  502.             }
  503.         mNewAlgoSample = MakeNewMenuItem(mmObjectsMenu,"New Algorithmic Sample",0);
  504.         if (mNewAlgoSample == NIL)
  505.             {
  506.                 goto MakeFunctionMenuFailurePoint;
  507.             }
  508.         mNewFunction = MakeNewMenuItem(mmObjectsMenu,"New Function Module",0);
  509.         if (mNewFunction == NIL)
  510.             {
  511.                 goto MakeFunctionMenuFailurePoint;
  512.             }
  513.         AppendSeparator(mmObjectsMenu);
  514.         mCalculator = MakeNewMenuItem(mmObjectsMenu,"Calculator",0);
  515.         if (mCalculator == NIL)
  516.             {
  517.                 goto MakeFunctionMenuFailurePoint;
  518.             }
  519.         AppendSeparator(mmObjectsMenu);
  520.         mEvaluateCalc = MakeNewMenuItem(mmObjectsMenu,"Evaluate",'D');
  521.         if (mEvaluateCalc == NIL)
  522.             {
  523.                 goto MakeFunctionMenuFailurePoint;
  524.             }
  525.         ShowMenu(mmObjectsMenu);
  526.  
  527.         mmFunctionMenu = MakeNewMenu("Build");
  528.         if (mmFunctionMenu == NIL)
  529.             {
  530.                 goto MakeFunctionMenuFailurePoint;
  531.             }
  532.         mBuildFunction = MakeNewMenuItem(mmFunctionMenu,"Compile",'K');
  533.         if (mBuildFunction == NIL)
  534.             {
  535.                 goto MakeSampleMenuFailedPoint;
  536.             }
  537.         AppendSeparator(mmFunctionMenu);
  538.         mUnbuildFunction = MakeNewMenuItem(mmFunctionMenu,"Remove Objects For This",0);
  539.         if (mUnbuildFunction == NIL)
  540.             {
  541.                 goto MakeSampleMenuFailedPoint;
  542.             }
  543.         mUnbuildAllFunctions = MakeNewMenuItem(mmFunctionMenu,"Remove Objects For All",0);
  544.         if (mUnbuildAllFunctions == NIL)
  545.             {
  546.                 goto MakeSampleMenuFailedPoint;
  547.             }
  548.         mBuildEntireProject = MakeNewMenuItem(mmFunctionMenu,"Build All Objects",'U');
  549.         if (mBuildEntireProject == NIL)
  550.             {
  551.                 goto MakeSampleMenuFailedPoint;
  552.             }
  553.         AppendSeparator(mmFunctionMenu);
  554.         mDisassembleFunction = MakeNewMenuItem(mmFunctionMenu,"Disassemble",0);
  555.         if (mDisassembleFunction == NIL)
  556.             {
  557.                 goto MakeSampleMenuFailedPoint;
  558.             }
  559.         AppendSeparator(mmFunctionMenu);
  560.         mAlgoSampToSample = MakeNewMenuItem(mmFunctionMenu,"Open Algorithmic Sample As New Sample",0);
  561.         if (mAlgoSampToSample == NIL)
  562.             {
  563.                 goto MakeSampleMenuFailedPoint;
  564.             }
  565.         ShowMenu(mmFunctionMenu);
  566.  
  567.         mmSampleMenu = MakeNewMenu("Samples");
  568.         if (mmSampleMenu == NIL)
  569.             {
  570.                 goto MakeSampleMenuFailedPoint;
  571.             }
  572.         mSampleEditLoop1 = MakeNewMenuItem(mmSampleMenu,"Edit Loop 1",'1');
  573.         if (mSampleEditLoop1 == NIL)
  574.             {
  575.                 goto MakeWindowMenuFailedPoint;
  576.             }
  577.         mSampleEditLoop2 = MakeNewMenuItem(mmSampleMenu,"Edit Loop 2",'2');
  578.         if (mSampleEditLoop2 == NIL)
  579.             {
  580.                 goto MakeWindowMenuFailedPoint;
  581.             }
  582.         mSampleEditLoop3 = MakeNewMenuItem(mmSampleMenu,"Edit Loop 3",'3');
  583.         if (mSampleEditLoop3 == NIL)
  584.             {
  585.                 goto MakeWindowMenuFailedPoint;
  586.             }
  587.         AppendSeparator(mmSampleMenu);
  588.         mImportWAVFormat = MakeNewMenuItem(mmSampleMenu,"Import WAV Sample",0);
  589.         if (mImportWAVFormat == NIL)
  590.             {
  591.                 goto MakeWindowMenuFailedPoint;
  592.             }
  593.         mImportAIFFFormat = MakeNewMenuItem(mmSampleMenu,"Import AIFF Sample",0);
  594.         if (mImportAIFFFormat == NIL)
  595.             {
  596.                 goto MakeWindowMenuFailedPoint;
  597.             }
  598.         mImportRAWFormat = MakeNewMenuItem(mmSampleMenu,"Import Raw Sample",0);
  599.         if (mImportRAWFormat == NIL)
  600.             {
  601.                 goto MakeWindowMenuFailedPoint;
  602.             }
  603.         AppendSeparator(mmSampleMenu);
  604.         mExportWAVFormat = MakeNewMenuItem(mmSampleMenu,"Export WAV Sample",0);
  605.         if (mExportWAVFormat == NIL)
  606.             {
  607.                 goto MakeWindowMenuFailedPoint;
  608.             }
  609.         mExportAIFFFormat = MakeNewMenuItem(mmSampleMenu,"Export AIFF Sample",0);
  610.         if (mExportAIFFFormat == NIL)
  611.             {
  612.                 goto MakeWindowMenuFailedPoint;
  613.             }
  614.         mExportRAWFormat = MakeNewMenuItem(mmSampleMenu,"Export Raw Sample",0);
  615.         if (mExportRAWFormat == NIL)
  616.             {
  617.                 goto MakeWindowMenuFailedPoint;
  618.             }
  619.         ShowMenu(mmSampleMenu);
  620.  
  621.         mmWindowMenu = MakeNewMenu("Windows");
  622.         if (mmWindowMenu == NIL)
  623.             {
  624.                 goto MakeWindowMenuFailedPoint;
  625.             }
  626.         ShowMenu(mmWindowMenu);
  627.  
  628.         PrepareStartupDocuments(argc,argv);
  629.         TryToOpenUntitledDocument = True;
  630.         ContinueFlag = True;
  631.         while (ContinueFlag)
  632.             {
  633.                 OrdType                    XLoc;
  634.                 OrdType                    YLoc;
  635.                 ModifierFlags        Modifiers;
  636.                 FileSpec*                StartupItem;
  637.                 WinType*                Window;
  638.                 char                        KeyPress;
  639.                 MenuItemType*        MenuItem;
  640.                 EventType                TheEvent;
  641.  
  642.                 /* see if there are any startup items to open */
  643.                 if (GetStartupObject(&StartupItem))
  644.                     {
  645.                         /* if it returns True, then we can go ahead */
  646.                         if (StartupItem == NIL)
  647.                             {
  648.                                 /* if we haven't opened an untitled document, and the thing */
  649.                                 /* returned True, except it returned a NIL item, then we */
  650.                                 /* can open an untitled document */
  651.                                 if (TryToOpenUntitledDocument)
  652.                                     {
  653.                                         OpenDocument(NIL);
  654.                                         TryToOpenUntitledDocument = False;
  655.                                     }
  656.                             }
  657.                          else
  658.                             {
  659.                                 /* if it isn't NIL, then open the actual thing */
  660.                                 /* this swallows the startup item record so we don't have */
  661.                                 /* do dispose of it */
  662.                                 FileOpener(StartupItem);
  663.                                 TryToOpenUntitledDocument = False;
  664.                             }
  665.                     }
  666. #if 0
  667.                 if (InitialAboutBoxStillVisible)
  668.                     {
  669.                         if (TimerDifference(ReadTimer(),StartupTime) > STARTUPDELAY)
  670.                             {
  671.                                 InitialAboutBoxStillVisible = False;
  672.                                 HideAnyAboutBoxes();
  673.                             }
  674.                     }
  675. #endif
  676.                 TheEvent = GetAnEvent(&XLoc,&YLoc,&Modifiers,&Window,&MenuItem,&KeyPress);
  677.                 switch (TheEvent)
  678.                     {
  679.                         case eMouseUp:
  680.                             break;
  681.                         case eMenuStarting:
  682.                             EnableMenuItem(mAboutThisProgram);
  683.                             EnableMenuItem(mNewFile);
  684.                             EnableMenuItem(mOpenFile);
  685.                             EnableMenuItem(mQuit);
  686.                             EnableMenuItem(mPlayAIFFFile);
  687.                             DispatchMenuStarting(Window);
  688.                             break;
  689.                         case eMenuCommand:
  690.                             if (MenuItem == mAboutThisProgram)
  691.                                 {
  692.                                     ShowAboutBox();
  693.                                 }
  694.                             else if (MenuItem == mOpenFile)
  695.                                 {
  696.                                     FileSpec*                    Where;
  697.                                     unsigned long            FileTypeList[3] = {ApplicationFileType,
  698.                                                                             CODE4BYTES('A','I','F','F'),
  699.                                                                             CODE4BYTES('A','I','F','C')};
  700.  
  701.                                     Where = GetFileStandard(3,FileTypeList);
  702.                                     if (Where != NIL)
  703.                                         {
  704.                                             FileOpener(Where);
  705.                                         }
  706.                                 }
  707.                             else if (MenuItem == mNewFile)
  708.                                 {
  709.                                     OpenDocument(NIL);
  710.                                 }
  711.                             else if (MenuItem == mQuit)
  712.                                 {
  713.                                     SetQuitPending();
  714.                                 }
  715.                             else if (MenuItem == mPlayAIFFFile)
  716.                                 {
  717.                                     PlayAIFFFile();
  718.                                 }
  719.                             else
  720.                                 {
  721.                                     DispatchProcessMenuCommand(Window,MenuItem);
  722.                                 }
  723.                             break;
  724.                         case eKeyPressed:
  725.                             DispatchDoKeyDown(Window,KeyPress,Modifiers);
  726.                             break;
  727.                         case eMouseDown:
  728.                             DispatchDoMouseDown(Window,XLoc,YLoc,Modifiers);
  729.                             break;
  730.                         case eWindowClosing:
  731.                             DispatchCloseWindow(Window);
  732.                             break;
  733.                         case eWindowResized:
  734.                             DispatchWindowJustResized(Window);
  735.                             break;
  736.                         case eActiveWindowChanged:
  737.                             DispatchActiveWindowJustChanged(Window);
  738.                             break;
  739.                         case eNoEvent:
  740.                         case eCheckCursor:
  741.                             DispatchDoIdle(Window,TheEvent == eCheckCursor,XLoc,YLoc,Modifiers);
  742.                             break;
  743.                         default:
  744.                             EXECUTE(PRERR(AllowResume,"Unimplemented event received"));
  745.                             break;
  746.                     }
  747.                 if (CheckQuitPending())
  748.                     {
  749.                         /* ask "are you sure" here; */
  750.                         DoCloseAllQuitPending();
  751.                         if (CheckQuitPending())
  752.                             {
  753.                                 /* if quit is still pending, then we exit */
  754.                                 ContinueFlag = False;
  755.                             }
  756.                     }
  757.             }
  758.         ClearStartupDocuments();
  759.  
  760.  
  761.         /* application cleanup */
  762.      LastMenuConstructionFailurePoint:
  763.         KillMenuAndDeleteItems(mmWindowMenu);
  764.      MakeWindowMenuFailedPoint:
  765.         KillMenuAndDeleteItems(mmSampleMenu);
  766.      MakeSampleMenuFailedPoint:
  767.         KillMenuAndDeleteItems(mmFunctionMenu);
  768.      MakeFunctionMenuFailurePoint:
  769.         KillMenuAndDeleteItems(mmObjectsMenu);
  770.      MakeObjectsMenuFailurePoint:
  771.         KillMenuAndDeleteItems(mmSearchMenu);
  772.      MakeSearchMenuFailurePoint:
  773.         KillMenuAndDeleteItems(mmEditMenu);
  774.      MakeEditMenuFailurePoint:
  775.         KillMenuAndDeleteItems(mmFileMenu);
  776.      MakeFileMenuFailurePoint:
  777.         KillMenuAndDeleteItems(mmAppleMenu);
  778.      MakeAppleMenuFailurePoint:
  779.         HideAnyAboutBoxes();
  780.         ShutdownGlobalWindowMenuList();
  781.      InitializeGlobalMenuWindowListFailurePoint:
  782.         ReleasePtr(GlobalReplaceString);
  783.      AllocGlobalReplaceStringFailurePoint:
  784.         ReleasePtr(GlobalSearchString);
  785.      AllocGlobalSearchStringFailurePoint:
  786.         ShutdownDocuments();
  787.      InitDocumentsFailurePoint:
  788.         ShutdownWindowDispatcher();
  789.      InitializeLittleButtonImagesFailurePoint:
  790.         ShutdownLittleButtonImages();
  791.      InitWindowDispatcherFailurePoint:
  792.         CleanupNoteButtonImages();
  793.      InitNoteButtonImagesFailurePoint:
  794.         CleanupNoteImages();
  795.      InitNoteImagesFailurePoint:
  796.         CleanupEditImages();
  797.      InitEditImagesFailurePoint:
  798.         ShutdownFactoring();
  799.  
  800.      InitFactoringFailurePoint:
  801.         /* level 1 cleanup */
  802.         ShutdownGrowIcon();
  803.      InitGrowIconFailurePoint:
  804.         ShutdownAlertSubsystem();
  805.  
  806.      InitAlertFailurePoint:
  807.         /* level 0 cleanup */
  808.         ShutdownScreen();
  809.  
  810.      InitScreenFailurePoint:
  811.         APRINT(("-main"));
  812.         return 0;
  813.     }
  814.